export default {
    //落地摩擦式--begin
    //图一首绳  20 | 128.4 | 513.4 | 587.6 | 1129.5
    //         斜1 | 轮2 | 斜2 | 轮3 |  直

    pointLocationHead1(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 1129.5);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 20;
        let linetwo = 128.4;
        let linethree = 513.4;
        let linefour = 587.6;
        let linefive = 1129.5;

        if (imgLength <= lineone) {
            //第一段斜线 起点坐标 280 , 296
            let angle = 67.5;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, imgLength);
            let cosSideValue = cosSideFun(angle, imgLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 280 - dotRadios + Number(cosSidePx);
            pxy = 296 - dotRadios + Number(sinSidePx);
        } else if (imgLength > lineone && imgLength < linetwo) {
            //以X轴平行半径切分弧线 上弧(18.3)  下弧(96.2)  切点位置 338 297
            //第二个滑轮  起点坐标 287 , 310  未点坐标 337 , 289

            //长度 - 上一段距离 = 弧长
            //默认下弧
            let arcLength = linetwo - 18.3 - imgLength;
            //超过X轴平行坐标为上弧   滚轮半径36
            if (imgLength > linetwo - 18.3) {
                arcLength = imgLength - (linetwo - 18.3);
            }
            let radius = 36;

            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            //默认下弧
            pxx = 338 - dotRadios - Number(cosSidePx);
            pxy = 297 - dotRadios + Number(sinSidePx);
            //超过X轴平行坐标为上弧
            if (imgLength > linetwo - 18.3) {
                pxy = 297 - dotRadios - Number(sinSidePx);
            }
        } else if (imgLength >= linetwo && imgLength <= linethree) {
            //第二段斜线 起点坐标 337 , 289
            //长度 - 上一段距离 = 弧长
            let lineLength = imgLength - linetwo;
            let angle = 60;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 337 - dotRadios - Number(cosSidePx);
            pxy = 289 - dotRadios - Number(sinSidePx);
        } else if (imgLength > linethree && imgLength < linefour) {
            //第一个滑轮  起点坐标 158 , 48

            //长度 - 上一段距离 = 弧长
            let arcLength = linefour - imgLength;
            let radius = 25;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 158 - dotRadios + Number(cosSidePx);
            pxy = 48 - dotRadios - Number(sinSidePx);
        } else if (imgLength >= linefour && imgLength <= linefive) {
            //再第一段直线距离  起点坐标 158 , 48

            let lineLength = imgLength - linefour;
            //把距离换算成像素
            let px = pxRatioFun3(lineLength);

            //减去元素一半的大小
            pxx = 158 - dotRadios;
            pxy = 48 - dotRadios + Number(px);
        }

        return {
            x: pxx,
            y: pxy,
        };
    },
    //图一未绳 440 | 495 | 595
    //         直 | 轮1  | 直
    pointLocationEnd1(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 595);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 440;
        let lineotwo = 495;
        let linethree = 595;

        if (imgLength <= 440) {
            //再第一段直线距离  起点坐标 184 , 228

            //把距离换算成像素
            let px = pxRatioFun3(imgLength);

            //减去元素一半的大小
            pxx = 184 - dotRadios;
            pxy = 228 - dotRadios + Number(px);
        } else if (imgLength > lineone && imgLength < lineotwo) {
            //第一个滑轮  起点坐标 184 , 558

            //长度 - 上一段距离 = 弧长
            let arcLength = imgLength - lineone;
            let radius = 17.5;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 184 - dotRadios - Number(cosSidePx);
            pxy = 558 - dotRadios + Number(sinSidePx);
        } else if (imgLength >= lineotwo && imgLength <= linethree) {
            //再第一段直线距离  起点坐标 158 , 558

            let lineLength = imgLength - lineotwo;
            //把距离换算成像素
            let px = pxRatioFun3(lineLength);

            //减去元素一半的大小
            pxx = 158 - dotRadios;
            pxy = 558 - dotRadios - Number(px);
        }

        return {
            x: pxx,
            y: pxy,
        };
    },
    //落地摩擦式--end
    //井塔摩擦式--begin
    //图二首绳 175.4 | 237.4 |  319.6 | 906.4
    //         直   | 斜1    | 轮     |  直
    pointLocationHead2(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 903.4);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 175.4;
        let linetwo = 237.4;
        let linethree = 316.6;
        let linefour = 903.4;

        if (imgLength <= 192) {
            //再第一段直线距离  起点坐标 217 , 233

            //把距离换算成像素
            let px = pxRatioFun3(imgLength);

            //减去元素一半的大小
            pxx = 217 - dotRadios;
            pxy = 233 - dotRadios - Number(px);
        } else if (imgLength > lineone && imgLength <= linetwo) {
            //第一段斜线 起点坐标 217 , 104
            //长度 - 上一段距离 = 弧长
            let lineLength = imgLength - lineone;
            let angle = 75;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 217 - dotRadios + Number(cosSidePx);
            pxy = 104 - dotRadios - Number(sinSidePx);
        } else if (imgLength > linetwo && imgLength < linethree) {
            //第一个滑轮  终点坐标 194 , 56

            //长度 - 上一段距离 = 弧长
            let arcLength = linethree - imgLength;
            let radius = 23.8;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 194 - dotRadios + Number(cosSidePx);
            pxy = 56 - dotRadios - Number(sinSidePx);
        } else if (imgLength >= linethree && imgLength <= linefour) {
            //再第一段直线距离  起点坐标 194 , 56

            let lineLength = imgLength - linethree;
            //把距离换算成像素
            let px = pxRatioFun3(lineLength);

            //减去元素一半的大小
            pxx = 194 - dotRadios;
            pxy = 56 - dotRadios + Number(px);
        }

        return {
            x: pxx,
            y: pxy,
        };
    },

    //井塔式尾绳
    //图二尾绳 397|	446.6|	498
    //         直 | 轮1  | 直
    pointLocationEnd2(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 498);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 397;
        let linetwo = 446.6;
        let linethree = 498;

        if (imgLength <= lineone) {
            //再第一段直线距离  起点坐标 217 , 267

            //把距离换算成像素
            let px = pxRatioFun3(imgLength);

            //减去元素一半的大小
            pxx = 217 - dotRadios;
            pxy = 267 - dotRadios + Number(px);
        } else if (imgLength > lineone && imgLength < linetwo) {
            //第一个滑轮  起点坐标 217 , 561

            //长度 - 上一段距离 = 弧长
            let arcLength = imgLength - lineone;
            let radius = 15.8;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 217 - dotRadios - Number(cosSidePx);
            pxy = 561 - dotRadios + Number(sinSidePx);
        } else if (imgLength >= linetwo && imgLength <= linethree) {
            //再第一段直线距离  起点坐标 194 , 561

            let lineLength = imgLength - linetwo;
            //把距离换算成像素
            let px = pxRatioFun3(lineLength);

            //减去元素一半的大小
            pxx = 194 - dotRadios;
            pxy = 561 - dotRadios - Number(px);
        }

        return {
            x: pxx,
            y: pxy,
        };
    },
    //井塔摩擦式--end

    //架空乘人装置--begin
    //起点：420，214   半径24.8
    //图三  96.9| 512  |587.3 |	665.2  | 762.1| 1177.2| 1252.5 | 1330.5
    //      直1 | 斜1  | 直2  |  圆弧   |  直3 |  斜2   |  直4   | 圆弧2
    pointLocation3(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 1330.4);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 96.9;
        let linetwo = 512;
        let linethree = 587.3;
        let linefour = 665.2;
        let linefive = 762.1;
        let linesix = 1177.2;
        let lineseven = 1252.5;
        let lineeight = 1330.5;

        if (imgLength <= lineone) {
            //第一段直线
            let px = pxRatioFun3(imgLength);
            pxx = 420 - dotRadios - Number(px);
            pxy = 214 - dotRadios;
        } else if (imgLength > lineone && imgLength <= linetwo) {
            //第一段斜线  起点坐标 348 , 215
            let lineLength = imgLength - lineone;
            let angle = 30;
            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 348 - dotRadios - Number(cosSidePx);
            pxy = 215 - dotRadios + Number(sinSidePx);
        } else if (imgLength > linetwo && imgLength <= linethree) {
            //第二段直线  起点坐标 83 , 368
            let lineLength = imgLength - linetwo;
            let px = pxRatioFun3(lineLength);
            pxx = 83 - dotRadios - Number(px);
            pxy = 368 - dotRadios;
        } else if (imgLength > linethree && imgLength <= linefour) {
            //圆弧  起点坐标 27 , 368  半径24.8
            let arcLength = imgLength - linethree;
            let radius = 24.8;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);
            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 27 - dotRadios - Number(sinSidePx);
            pxy = 368 - dotRadios + Number(cosSidePx);
            // pxx = 25 - dotRadios - Number(sinSidePx);
            // pxy = 332 + dotRadios + Number(cosSidePx);
        } else if (imgLength > linefour && imgLength <= linefive) {
            //第三段直线  起点坐标 27 , 405
            let lineLength = imgLength - linefour;
            let px = pxRatioFun3(lineLength);
            pxx = 27 - dotRadios + Number(px);
            pxy = 405 - dotRadios;
        } else if (imgLength > linefive && imgLength <= linesix) {
            //第二段斜线  起点坐标 98 , 405
            let lineLength = imgLength - linefive;
            let angle = 30;
            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 98 - dotRadios + Number(cosSidePx);
            pxy = 405 - dotRadios - Number(sinSidePx);
        } else if (imgLength > linesix && imgLength <= lineseven) {
            //第四段直线  起点坐标 364 , 251
            let lineLength = imgLength - linesix;
            let px = pxRatioFun3(lineLength);
            pxx = 364 - dotRadios + Number(px);
            pxy = 251 - dotRadios;
        } else if (imgLength > lineseven && imgLength <= lineeight) {
            //圆弧2  起点坐标 420 , 251
            let arcLength = imgLength - lineseven;
            let radius = 24.8;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);
            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            // pxx = 423 - dotRadios + Number(cosSidePx);
            // pxy = 214 - dotRadios - Number(sinSidePx);
            pxx = 420 - dotRadios + Number(sinSidePx);
            pxy = 251 - dotRadios - Number(cosSidePx);
        }
        // else if (imgLength > lineeight && imgLength <= 1440) {
        //     //第三段直线  起点坐标 25 , 369
        //     let lineLength = imgLength - lineeight;
        //     let px = pxRatioFun3(lineLength);
        //     pxx = 425 - dotRadios - Number(px);
        //     pxy = 178 - dotRadios;
        // }

        return {
            x: pxx,
            y: pxy,
        };
    },
    //架空乘人装置--end

    //立井单箕斗缠绕--begin
    //起点：336,129
    //图四  197.7| 259.2 | 877.6
    //      斜1  | 圆弧  | 直2
    pointLocation4(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 877.6);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 197.7;
        let linetwo = 259.2;
        let linethree = 877.6;

        if (imgLength <= lineone) {
            //第一段斜线 起点坐标 217 , 104
            let lineLength = imgLength;
            let angle = 31.5;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 336 - dotRadios - Number(cosSidePx);
            pxy = 129 - dotRadios - Number(sinSidePx);
        } else if (imgLength > lineone && imgLength <= linetwo) {
            //第一段圆弧 终点坐标 184 , 68
            //长度 - 上一段距离 = 弧长
            let arcLength = linetwo - imgLength;
            let radius = 24.2;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 184 - dotRadios + Number(cosSidePx);
            pxy = 68 - dotRadios - Number(sinSidePx);
        } else if (imgLength > linetwo && imgLength <= linethree) {
            //第二段直线距离  起点坐标 184 , 68

            let lineLength = imgLength - linetwo;
            //把距离换算成像素
            let px = pxRatioFun3(lineLength);

            //减去元素一半的大小
            pxx = 184 - dotRadios;
            pxy = 68 - dotRadios + Number(px);
        }

        return {
            x: pxx,
            y: pxy,
        };
    },
    //立井单箕斗缠绕--end

    //立井双箕斗缠绕--begin
    //上绳 321,142
    //图五上绳   斜1  |  圆弧1  |  直1
    //          240.7|  291.6  |  910
    //圆弧1角度122.5
    pointLocationHead5(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 910);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 240.7;
        let linetwo = 291.6;
        let linethree = 910;

        if (imgLength <= lineone) {
            //第一段斜线 起点坐标 321 , 142
            //长度 - 上一段距离 = 弧长
            //角度31.5
            let lineLength = imgLength;
            let angle = 31.5;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 321 - dotRadios - Number(cosSidePx);
            pxy = 142 - dotRadios - Number(sinSidePx);
        } else if (imgLength > lineone && imgLength <= linetwo) {
            //第一段圆弧 终点坐标 144 , 65
            //长度 - 上一段距离 = 弧长
            let arcLength = linetwo - imgLength;
            let radius = 23.8;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 144 - dotRadios + Number(cosSidePx);
            pxy = 65 - dotRadios - Number(sinSidePx);
        } else if (imgLength > linetwo && imgLength <= linethree) {
            //第一段直线距离  起点坐标 144 , 65

            let lineLength = imgLength - linetwo;
            //把距离换算成像素
            let px = pxRatioFun3(lineLength);

            //减去元素一半的大小
            pxx = 144 - dotRadios;
            pxy = 65 - dotRadios + Number(px);
        }
        return {
            x: pxx,
            y: pxy,
        };
    },
    //下绳 277,186
    //图五下绳   斜1  |  圆弧1  |  直1
    //          155.9|  208.2 |  742.7
    //圆弧1角度126°
    pointLocationEnd5(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 742.7);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 155.9;
        let linetwo = 208.2;
        let linethree = 742.7;

        if (imgLength <= lineone) {
            //第一段斜线 起点坐标 295 , 180
            //长度 - 上一段距离 = 弧长
            let lineLength = imgLength;
            let angle = 36;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 295 - dotRadios - Number(cosSidePx);
            pxy = 180 - dotRadios - Number(sinSidePx);
        } else if (imgLength > lineone && imgLength <= linetwo) {
            //第一段圆弧 终点坐标 175 , 127
            //长度 - 上一段距离 = 弧长
            let arcLength = linetwo - imgLength;
            let radius = 23.8;
            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            pxx = 175 - dotRadios + Number(cosSidePx);
            pxy = 127 - dotRadios - Number(sinSidePx);
        } else if (imgLength > linetwo && imgLength <= linethree) {
            //第一段直线距离  起点坐标 175 , 127

            let lineLength = imgLength - linetwo;
            //把距离换算成像素
            let px = pxRatioFun3(lineLength);

            //减去元素一半的大小
            pxx = 175 - dotRadios;
            pxy = 127 - dotRadios + Number(px);
        }
        return {
            x: pxx,
            y: pxy,
        };
    },
    //立井双箕斗缠绕--begin

    //斜井缠绕式--begin
    //上绳 27,250
    //图六上绳   斜1  |  圆弧1  |  斜2
    //          163.1|  176.0  |  561.8

    pointLocationBegin6(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 561.8);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 163.1;
        let linetwo = 176.0;
        let linethree = 561.8;

        if (imgLength <= lineone) {
            //第一段斜线 起点坐标 27 , 250
            //长度 - 上一段距离 = 弧长
            let lineLength = imgLength;
            let angle = 18.8;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 27 - dotRadios + Number(cosSidePx);
            pxy = 250 - dotRadios - Number(sinSidePx);
        } else if (imgLength > lineone && imgLength <= linetwo) {
            //以y轴平行半径切分弧线 左弧(5.8)  右弧(7.1)  切点位置 145 210
            //长度 - 上一段距离 = 弧长
            //默认左弧
            let arcLength = linetwo - 7.1 - imgLength;
            //超过y轴平行坐标为右弧
            if (imgLength > linetwo - 7.1) {
                arcLength = imgLength - (linetwo - 7.1);
            }
            let radius = 17.9;

            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            //默认左弧
            pxx = 145 - dotRadios - Number(sinSidePx);
            pxy = 210 - dotRadios - Number(cosSidePx);
            //超过y轴平行坐标为右弧
            if (imgLength > linetwo - 7.1) {
                pxx = 145 - dotRadios + Number(sinSidePx);
            }
            // //第一段圆弧 起点坐标 140 , 211
            // //长度 - 上一段距离 = 弧长
            // let arcLength = imgLength - lineone;
            // let radius = 18.9;
            // //通过弧长和半径计算角度
            // let arcAngle = angleFun(arcLength, radius);

            // //获取对边 临边的长度
            // let sinSideValue = sinSideFun(arcAngle, radius);
            // let cosSideValue = cosSideFun(arcAngle, radius);

            // //把长度距离换算成像素
            // let sinSidePx = pxRatioFun1(sinSideValue);
            // let cosSidePx = pxRatioFun1(radius - cosSideValue);

            // pxx = 140 - dotRadios + Number(cosSidePx);
            // pxy = 211 - dotRadios - Number(sinSidePx);
        } else if (imgLength > linetwo && imgLength <= linethree) {
            //第二段斜线 起点坐标 154 , 212
            //长度 - 上一段距离 = 弧长
            let lineLength = imgLength - linetwo;
            let angle = 22.8;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 154 - dotRadios + Number(cosSidePx);
            pxy = 212 - dotRadios + Number(sinSidePx);
        }
        return {
            x: pxx,
            y: pxy,
        };
    },
    //下绳 43,286
    //图六下绳   斜1  |  圆弧1  |  斜2
    //          163.1|  176.0  |  536

    pointLocationEnd6(installLength, loaction) {
        loaction = Math.abs(loaction);
        //图片绳子总长与安装总长度比例
        let totalLengthRatioValue = totalLengthRatioFun(installLength, 536.3);
        //换算在图片上的长度
        let imgLength = Number(totalLengthRatioValue) * loaction;

        let dotRadios = 5;
        let pxx;
        let pxy;
        let lineone = 163.1;
        let linetwo = 176;
        let linethree = 536.3;

        if (imgLength <= lineone) {
            //第一段斜线 起点坐标 43 , 286
            //长度 - 上一段距离 = 弧长
            let lineLength = imgLength;
            let angle = 18.8;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 43 - dotRadios + Number(cosSidePx);
            pxy = 286 - dotRadios - Number(sinSidePx);
        } else if (imgLength > lineone && imgLength <= linetwo) {
            //以y轴平行半径切分弧线 左弧(5.8)  右弧(7.1)  切点位置 161 247
            //长度 - 上一段距离 = 弧长
            //默认左弧
            let arcLength = linetwo - 7.1 - imgLength;
            //超过y轴平行坐标为右弧
            if (imgLength > linetwo - 7.1) {
                arcLength = imgLength - (linetwo - 7.1);
            }
            let radius = 17.9;

            //通过弧长和半径计算角度
            let arcAngle = angleFun(arcLength, radius);

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(arcAngle, radius);
            let cosSideValue = cosSideFun(arcAngle, radius);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(radius - cosSideValue);

            //默认左弧
            pxx = 161 - dotRadios - Number(sinSidePx);
            pxy = 247 - dotRadios - Number(cosSidePx);
            //超过y轴平行坐标为右弧
            if (imgLength > linetwo - 7.1) {
                pxx = 161 - dotRadios + Number(sinSidePx);
            }
        } else if (imgLength > linetwo && imgLength <= linethree) {
            //第二段斜线 起点坐标 169 , 248
            //长度 - 上一段距离 = 弧长
            let lineLength = imgLength - linetwo;
            let angle = 22.8;

            //获取对边 临边的长度
            let sinSideValue = sinSideFun(angle, lineLength);
            let cosSideValue = cosSideFun(angle, lineLength);

            //把长度距离换算成像素
            let sinSidePx = pxRatioFun3(sinSideValue);
            let cosSidePx = pxRatioFun3(cosSideValue);

            pxx = 168 - dotRadios + Number(cosSidePx);
            pxy = 248 - dotRadios + Number(sinSidePx);
        }
        return {
            x: pxx,
            y: pxy,
        };
    },
    //斜井缠绕式--end
};

//图片绳子总长与安装总长度比例
function totalLengthRatioFun(installLength, imgLength) {
    return (imgLength / installLength).toFixed(5);
}

//绳子长度与图片像素比例
// function pxRatioFun1(length) {
//     return ((length / 4) * 3).toFixed(5);
// }
// function pxRatioFun2(length) {
//     return (length / 1.484).toFixed(5);
// }
function pxRatioFun3(length) {
    return ((length / 50) * 36.5).toFixed(5);
}
//正弦sin值计算
function sinFun(angle) {
    return Math.sin((angle * Math.PI) / 180);
}
//对边长度
function sinSideFun(angle, radius) {
    return sinFun(angle) * radius;
}

//余弦cos值计算
function cosFun(angle) {
    return Math.cos((angle * Math.PI) / 180);
}
//临边长度
function cosSideFun(angle, radius) {
    return cosFun(angle) * radius;
}

//通过弧长半径计算角度
function angleFun(arcLength, radius) {
    return (arcLength * 180) / radius / Math.PI;
}
